MCPForUnity/Editor/Helpers/PackageDetector.cs (2)

135-137: Limit scan scope to Assets/Packages to avoid heavy project-wide traversal.

Scanning the entire project root can walk Library, Temp, etc. Prefer Assets and Packages only.

Apply this diff:

-                // Find all MCPForUnityTools folders in project
-                var toolsFolders = System.IO.Directory.GetDirectories(projectRoot, "MCPForUnityTools", System.IO.SearchOption.AllDirectories);
+                // Find all MCPForUnityTools folders under Assets and Packages only
+                var toolsFolders = new System.Collections.Generic.List<string>();
+                string assetsDir = System.IO.Path.Combine(projectRoot, "Assets");
+                if (System.IO.Directory.Exists(assetsDir))
+                    toolsFolders.AddRange(System.IO.Directory.GetDirectories(assetsDir, "MCPForUnityTools", System.IO.SearchOption.AllDirectories));
+                string packagesDir = System.IO.Path.Combine(projectRoot, "Packages");
+                if (System.IO.Directory.Exists(packagesDir))
+                    toolsFolders.AddRange(System.IO.Directory.GetDirectories(packagesDir, "MCPForUnityTools", System.IO.SearchOption.AllDirectories));

---

181-213: Deduplicate GetToolsFolderIdentifier to avoid drift.

This logic is duplicated here and in ServerInstaller. Prefer a single source of truth.

• Change ServerInstaller.GetToolsFolderIdentifier(...) to internal static.
• Use that here and remove this duplicate method.

Proposed changes:

In ServerInstaller.cs (make method internal):

-        private static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)

In PackageDetector.cs (remove this method and call ServerInstaller.GetToolsFolderIdentifier(folder) where needed).

MCPForUnity/Editor/Helpers/ServerInstaller.cs (3)

421-423: Reduce scan scope to Assets/Packages for performance.

Avoid traversing Library/Temp etc. on each domain reload.

Apply this diff:

-                // Find all MCPForUnityTools folders
-                var toolsFolders = Directory.GetDirectories(projectRoot, "MCPForUnityTools", SearchOption.AllDirectories);
+                // Find all MCPForUnityTools folders under Assets and Packages only
+                var toolsFolders = new List<string>();
+                var assetsDir = Path.Combine(projectRoot, "Assets");
+                if (Directory.Exists(assetsDir))
+                    toolsFolders.AddRange(Directory.GetDirectories(assetsDir, "MCPForUnityTools", SearchOption.AllDirectories));
+                var packagesDir = Path.Combine(projectRoot, "Packages");
+                if (Directory.Exists(packagesDir))
+                    toolsFolders.AddRange(Directory.GetDirectories(packagesDir, "MCPForUnityTools", SearchOption.AllDirectories));

---

494-531: Expose GetToolsFolderIdentifier for reuse.

Make this helper internal so PackageDetector can reuse it and remove duplicate logic.

Apply this diff:

-        private static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)

---

483-487: Optional: log skipped tools for visibility.

You track skippedCount but don't surface it.

Apply this diff:

                 if (copiedCount > 0)
                 {
                     McpLog.Info($"Copied {copiedCount} Unity project tool(s) to server");
                 }
+                else if (skippedCount > 0)
+                {
+                    McpLog.Info($"All Unity project tools up-to-date ({skippedCount} skipped)");
+                }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

410-492: Prevent copy failures, avoid filename collisions, and limit scan scope.

• Ensure dest tools dir exists before File.Copy.
• Flat-copying .py into a shared tools root risks overwriting between multiple MCPForUnityTools folders (same filenames). Copy into a per-folder subdirectory keyed by folderIdentifier.
• Limit scan to Assets/ and Packages/ to avoid deep recursion into Library/.git and speed up. Also clean stale .py removed upstream.

Apply this diff:

 private static void CopyUnityProjectTools(string destToolsDir)
 {
     try
     {
         // Get Unity project root
         string projectRoot = Directory.GetParent(Application.dataPath)?.FullName;
         if (string.IsNullOrEmpty(projectRoot))
         {
             return;
         }
 
+        // Ensure destination tools directory exists
+        Directory.CreateDirectory(destToolsDir);
+
-        // Find all MCPForUnityTools folders
-        var toolsFolders = Directory.GetDirectories(projectRoot, "MCPForUnityTools", SearchOption.AllDirectories);
+        // Find all MCPForUnityTools folders (limit to Assets/ and Packages/)
+        var searchRoots = new[] { Path.Combine(projectRoot, "Assets"), Path.Combine(projectRoot, "Packages") }
+            .Where(Directory.Exists);
+        var toolsFolders = searchRoots
+            .SelectMany(root => Directory.GetDirectories(root, "MCPForUnityTools", SearchOption.AllDirectories))
+            .ToArray();
 
         int copiedCount = 0;
         int skippedCount = 0;
 
         foreach (var folder in toolsFolders)
         {
             // Generate unique identifier for this tools folder based on its parent directory structure
             // e.g., "MooseRunner_MCPForUnityTools" or "MyPackage_MCPForUnityTools"
             string folderIdentifier = GetToolsFolderIdentifier(folder);
-            string versionTrackingFile = Path.Combine(destToolsDir, $"{folderIdentifier}_version.txt");
+            string destToolFolder = Path.Combine(destToolsDir, folderIdentifier);
+            string versionTrackingFile = Path.Combine(destToolFolder, "_version.txt");
 
             // Read source version
             string sourceVersionFile = Path.Combine(folder, "version.txt");
             string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
 
             // Read installed version (tracked separately per tools folder)
             string installedVersion = ReadVersionFile(versionTrackingFile);
 
             // Check if update is needed (version different or no tracking file)
             bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
 
             if (needsUpdate)
             {
                 // Get all .py files (excluding __init__.py)
                 var pyFiles = Directory.GetFiles(folder, "*.py")
                     .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
 
+                // Ensure per-tool destination exists
+                Directory.CreateDirectory(destToolFolder);
+
+                // Cleanup stale .py files that were removed upstream
+                try
+                {
+                    var sourceNames = new HashSet<string>(pyFiles.Select(f => Path.GetFileName(f)), StringComparer.OrdinalIgnoreCase);
+                    foreach (var destPy in Directory.GetFiles(destToolFolder, "*.py"))
+                    {
+                        if (!sourceNames.Contains(Path.GetFileName(destPy)))
+                        {
+                            File.Delete(destPy);
+                        }
+                    }
+                }
+                catch (Exception cleanupEx)
+                {
+                    McpLog.Warn($"Failed to cleanup stale files for {folderIdentifier}: {cleanupEx.Message}");
+                }
+
                 foreach (var pyFile in pyFiles)
                 {
                     string fileName = Path.GetFileName(pyFile);
-                    string destFile = Path.Combine(destToolsDir, fileName);
+                    string destFile = Path.Combine(destToolFolder, fileName);
 
                     try
                     {
                         File.Copy(pyFile, destFile, overwrite: true);
                         copiedCount++;
                         McpLog.Info($"Copied Unity project tool: {fileName} from {folderIdentifier} (v{sourceVersion})");
                     }
                     catch (Exception ex)
                     {
                         McpLog.Warn($"Failed to copy {fileName}: {ex.Message}");
                     }
                 }
 
                 // Update version tracking file
                 try
                 {
                     File.WriteAllText(versionTrackingFile, sourceVersion);
                 }
                 catch (Exception ex)
                 {
                     McpLog.Warn($"Failed to write version tracking file for {folderIdentifier}: {ex.Message}");
                 }
             }
             else
             {
                 skippedCount++;
             }
         }
 
         if (copiedCount > 0)
         {
             McpLog.Info($"Copied {copiedCount} Unity project tool(s) to server");
         }
     }
     catch (Exception ex)
     {
         McpLog.Warn($"Failed to scan Unity project for tools: {ex.Message}");
     }
 }

Note: If tools rely on package-style relative imports, consider copying their __init__.py into the per-folder subdir to preserve package semantics. Please confirm expected import pattern.

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

498-531: Consolidate GetToolsFolderIdentifier into a shared helper
Extract the duplicate logic from ServerInstaller.cs and PackageDetector.cs into a single utility method to keep identifier rules consistent.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

455-489: Don’t create per-folder dirs when no .py files; add to active set only if a tool exists.

Currently the subdir is created and left empty when no .py files are found. Move enumeration before creating the subdir and before adding to activeFolderIdentifiers.

Apply this diff:

-                    // Generate unique identifier for this tools folder based on its parent directory structure
-                    // e.g., "MooseRunner_MCPForUnityTools" or "MyPackage_MCPForUnityTools"
-                    string folderIdentifier = GetToolsFolderIdentifier(folder);
-                    activeFolderIdentifiers.Add(folderIdentifier);
-
-                    // Create per-folder subdirectory in destToolsDir
-                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-                    Directory.CreateDirectory(destFolderSubdir);
-
-                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
-
-                    // Read source version
-                    string sourceVersionFile = Path.Combine(folder, "version.txt");
-                    string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
-
-                    // Read installed version (tracked separately per tools folder)
-                    string installedVersion = ReadVersionFile(versionTrackingFile);
-
-                    // Check if update is needed (version different or no tracking file)
-                    bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
-
-                    if (needsUpdate)
-                    {
-                        // Get all .py files (excluding __init__.py)
-                        var pyFiles = Directory.GetFiles(folder, "*.py")
-                            .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
-                            
-                        // Skip folders with no .py files
-                        if (!pyFiles.Any())
-                        { 
-                            skippedCount++; 
-                            continue; 
-                        }
+                    // Get all .py files (excluding __init__.py)
+                    var pyFiles = Directory.GetFiles(folder, "*.py")
+                        .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
+
+                    // Skip folders with no .py files (don't add to active set and don't create subdir)
+                    if (!pyFiles.Any())
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    // Generate identifier only for valid tool folders and mark active
+                    string folderIdentifier = GetToolsFolderIdentifier(folder);
+                    activeFolderIdentifiers.Add(folderIdentifier);
+
+                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
+                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
+
+                    // Read versions
+                    string sourceVersionFile = Path.Combine(folder, "version.txt");
+                    string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
+                    string installedVersion = ReadVersionFile(versionTrackingFile);
+
+                    bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
+
+                    if (needsUpdate)
+                    {
+                        Directory.CreateDirectory(destFolderSubdir);

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

435-447: Deduplicate “Packages” vs “Library/PackageCache” results.

Scanning both can find the same tool twice. Prefer the Packages path when both exist; skip PackageCache duplicates.

Would you like me to propose a small de-dupe map keyed by package folder name (preferring “Packages/” over “Library/PackageCache/”)?

---

480-489: Verify intent: excluding init.py and not copying subdirectories.

If tools use packages or one‑level submodules, skipping init.py and not copying subdirs may break imports.

• Option A: keep single‑file tool policy; document it clearly.
• Option B: copy one‑level subdirectories (skip pycache, venvs) and include init.py when present.
  Do you want a patch for Option B?

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

596-629: Critical: Address unresolved identifier collision and PackageCache issues.

The previous review identified two problems that remain unfixed:

1. PackageCache not handled: For paths like Library/PackageCache/com.example@1.0.0/Editor/MCPForUnityTools, the code doesn't recognize PackageCache as a valid root, falling back to the generic Editor_MCPForUnityTools identifier.

2. Collision risk: Multiple packages under the same parent produce identical identifiers. For example:

   • Assets/Plugins/Package1/Editor/MCPForUnityTools → Assets_Plugins_MCPForUnityTools
   • Assets/Plugins/Package2/Editor/MCPForUnityTools → Assets_Plugins_MCPForUnityTools

   These collisions cause tools to overwrite each other.

Apply the diff from the previous review to fix both issues:

 internal static string GetToolsFolderIdentifier(string toolsFolderPath)
 {
     try
     {
-        // Get parent directory name (e.g., "Editor" or package name)
-        DirectoryInfo parent = Directory.GetParent(toolsFolderPath);
-        if (parent == null) return "MCPForUnityTools";
-
-        // Walk up to find a distinctive parent (Assets/PackageName or Packages/PackageName)
-        DirectoryInfo current = parent;
-        while (current != null)
-        {
-            string name = current.Name;
-            DirectoryInfo grandparent = current.Parent;
-
-            // Stop at Assets, Packages, or if we find a package-like structure
-            if (grandparent != null &&
-                (grandparent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
-                 grandparent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase)))
-            {
-                return $"{grandparent.Name}_{name}_MCPForUnityTools";
-            }
-
-            current = grandparent;
-        }
-
-        // Fallback: use immediate parent
-        return $"{parent.Name}_MCPForUnityTools";
+        // toolsFolderPath → .../<PackageFolder>/Editor/MCPForUnityTools
+        var editorDir = Directory.GetParent(toolsFolderPath);      // Editor
+        var packageDir = editorDir?.Parent;                         // <PackageFolder>
+        if (packageDir == null) return "MCPForUnityTools";
+
+        // Find root (Assets / Packages / PackageCache)
+        DirectoryInfo current = packageDir;
+        while (current?.Parent != null)
+        {
+            var p = current.Parent;
+            if (p.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
+                p.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                p.Name.Equals("PackageCache", StringComparison.OrdinalIgnoreCase))
+            {
+                return $"{p.Name}_{current.Name}_MCPForUnityTools";
+            }
+            current = p;
+        }
+
+        // Fallback: use package dir name
+        return $"{packageDir.Name}_MCPForUnityTools";
     }
     catch
     {
         return "MCPForUnityTools";
     }
 }

This ensures unique identifiers by including the package folder name directly above Editor, preventing collisions between different packages under the same parent directory, and properly handling PackageCache locations.

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

462-465: Consider deferring subdirectory creation until after version check.

The subdirectory is created on line 464 before checking if an update is needed on line 478. For up-to-date folders, this performs unnecessary directory creation operations.

Apply this diff to defer directory creation:

         string folderIdentifier = GetToolsFolderIdentifier(folder);
         activeFolderIdentifiers.Add(folderIdentifier);
 
-        // Create per-folder subdirectory in destToolsDir
-        string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-        Directory.CreateDirectory(destFolderSubdir);
-
+        string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
         string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
 
         // Read source version
         string sourceVersionFile = Path.Combine(folder, "version.txt");
         string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
 
         // Read installed version (tracked separately per tools folder)
         string installedVersion = ReadVersionFile(versionTrackingFile);
 
         // Check if update is needed (version different or no tracking file)
         bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
 
         if (needsUpdate)
         {
+            // Create per-folder subdirectory in destToolsDir
+            Directory.CreateDirectory(destFolderSubdir);
+
             // Get all .py files (excluding __init__.py)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

462-465: Avoid creating empty dest subdirs — create lazily after confirming .py files.

Create destFolderSubdir only when pyFiles.Any() and an update is needed; prevents noise from empty folders.

-                    // Create per-folder subdirectory in destToolsDir
-                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-                    Directory.CreateDirectory(destFolderSubdir);
-
-                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
+                    // Prepare paths; create dest subdir lazily
+                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
+                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
...
-                        // Skip folders with no .py files
+                        // Skip folders with no .py files
                         if (!pyFiles.Any())
                         { 
                             skippedCount++; 
                             continue; 
                         }
 
+                        // Ensure destination subdir exists only when we actually copy
+                        Directory.CreateDirectory(destFolderSubdir);

Also applies to: 484-489

---

596-629: Identifier collisions for PackageCache — derive stable, unique names (critical).

Current logic doesn’t handle Library/PackageCache; many tools resolve to “Editor_MCPForUnityTools”, causing overwrites and bad cleanup.

-        internal static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)
         {
             try
             {
-                // Get parent directory name (e.g., "Editor" or package name)
-                DirectoryInfo parent = Directory.GetParent(toolsFolderPath);
-                if (parent == null) return "MCPForUnityTools";
-
-                // Walk up to find a distinctive parent (Assets/PackageName or Packages/PackageName)
-                DirectoryInfo current = parent;
-                while (current != null)
-                {
-                    string name = current.Name;
-                    DirectoryInfo grandparent = current.Parent;
-
-                    // Stop at Assets, Packages, or if we find a package-like structure
-                    if (grandparent != null &&
-                        (grandparent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
-                         grandparent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase)))
-                    {
-                        return $"{grandparent.Name}_{name}_MCPForUnityTools";
-                    }
-
-                    current = grandparent;
-                }
-
-                // Fallback: use immediate parent
-                return $"{parent.Name}_MCPForUnityTools";
+                // toolsFolderPath .../<PackageFolder>/Editor/MCPForUnityTools
+                var editorDir = Directory.GetParent(toolsFolderPath);       // Editor
+                var packageDir = editorDir?.Parent;                         // <PackageFolder>
+                if (packageDir == null) return "MCPForUnityTools";
+
+                // Find root (Assets / Packages / PackageCache)
+                DirectoryInfo current = packageDir;
+                while (current?.Parent != null)
+                {
+                    var p = current.Parent;
+                    if (p.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
+                        p.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                        p.Name.Equals("PackageCache", StringComparison.OrdinalIgnoreCase))
+                    {
+                        return $"{p.Name}_{current.Name}_MCPForUnityTools";
+                    }
+                    current = p;
+                }
+
+                // Fallback: use package dir name
+                return $"{packageDir.Name}_MCPForUnityTools";
             }
             catch
             {
                 return "MCPForUnityTools";
             }
         }

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

425-447: Reduce duplication: prefer Packages over PackageCache and stream directory enumeration.

• Use Directory.EnumerateDirectories to avoid loading huge lists.
• Skip PackageCache tools when the corresponding Packages//Editor/MCPForUnityTools exists to prevent duplicate installs.

Example approach:

• Keep searchRoots ordered: Assets → Packages → PackageCache.
• When iterating PackageCache folders, map “com.pkg@x.y.z” → “com.pkg” and skip if Packages/com.pkg/Editor/MCPForUnityTools exists.

---

449-451: Remove unused skippedCount or log it.

It’s incremented but never used.

-                int copiedCount = 0;
-                int skippedCount = 0;
+                int copiedCount = 0;
...
-                        { 
-                            skippedCount++; 
-                            continue; 
-                        }
+                        { 
+                            continue; 
+                        }
...
-                        skippedCount++;

Also applies to: 487-489, 525-526

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

596-629: Fix PackageCache identifier collisions to prevent tool overwrites.

The current logic doesn't check for PackageCache in the grandparent condition (lines 612-614), causing all PackageCache tools with the same structure to generate identical identifiers (e.g., Editor_MCPForUnityTools). This leads to collisions where tools from different packages overwrite each other.

For example:

• Library/PackageCache/com.pkg-a@1.0.0/Editor/MCPForUnityTools → Editor_MCPForUnityTools
• Library/PackageCache/com.pkg-b@2.0.0/Editor/MCPForUnityTools → Editor_MCPForUnityTools (collision!)

Apply this diff to include the package name and distinguish PackageCache paths:

         internal static string GetToolsFolderIdentifier(string toolsFolderPath)
         {
             try
             {
-                // Get parent directory name (e.g., "Editor" or package name)
-                DirectoryInfo parent = Directory.GetParent(toolsFolderPath);
-                if (parent == null) return "MCPForUnityTools";
-
-                // Walk up to find a distinctive parent (Assets/PackageName or Packages/PackageName)
-                DirectoryInfo current = parent;
+                // toolsFolderPath → .../Editor/MCPForUnityTools
+                var editorDir = Directory.GetParent(toolsFolderPath);      // Editor
+                var packageDir = editorDir?.Parent;                         // Package folder
+                if (packageDir == null) return "MCPForUnityTools";
+
+                // Walk up to find root (Assets / Packages / PackageCache)
+                DirectoryInfo current = packageDir;
                 while (current != null)
                 {
-                    string name = current.Name;
-                    DirectoryInfo grandparent = current.Parent;
-
-                    // Stop at Assets, Packages, or if we find a package-like structure
-                    if (grandparent != null &&
-                        (grandparent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
-                         grandparent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase)))
+                    var parent = current.Parent;
+                    if (parent != null &&
+                        (parent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
+                         parent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                         parent.Name.Equals("PackageCache", StringComparison.OrdinalIgnoreCase)))
                     {
-                        return $"{grandparent.Name}_{name}_MCPForUnityTools";
+                        return $"{parent.Name}_{current.Name}_MCPForUnityTools";
                     }
-
-                    current = grandparent;
+                    current = parent;
                 }
 
-                // Fallback: use immediate parent
-                return $"{parent.Name}_MCPForUnityTools";
+                // Fallback: use package directory name
+                return $"{packageDir.Name}_MCPForUnityTools";
             }
             catch
             {
                 return "MCPForUnityTools";
             }
         }

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

463-489: Consider deferring directory creation until needed.

The destination subdirectory is created unconditionally (line 463) even when no update is required or no .py files exist. While this doesn't cause functional issues, deferring the creation until after the needsUpdate and pyFiles checks would be more efficient.

Apply this diff to defer directory creation:

                     string folderIdentifier = GetToolsFolderIdentifier(folder);
                     activeFolderIdentifiers.Add(folderIdentifier);
 
-                    // Create per-folder subdirectory in destToolsDir
-                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-                    Directory.CreateDirectory(destFolderSubdir);
+                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
 
                     string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
 
                     // Read source version
                     string sourceVersionFile = Path.Combine(folder, "version.txt");
                     string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
 
                     // Read installed version (tracked separately per tools folder)
                     string installedVersion = ReadVersionFile(versionTrackingFile);
 
                     // Check if update is needed (version different or no tracking file)
                     bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
 
                     if (needsUpdate)
                     {
                         // Get all .py files (excluding __init__.py)
                         var pyFiles = Directory.GetFiles(folder, "*.py")
                             .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
                             
                         // Skip folders with no .py files
                         if (!pyFiles.Any())
                         { 
                             skippedCount++; 
                             continue; 
                         }
+
+                        // Create per-folder subdirectory now that we know we need it
+                        Directory.CreateDirectory(destFolderSubdir);
 
                         bool copyFailed = false;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: JohanHoltby
PR: CoplayDev/unity-mcp#309
File: MCPForUnity/Editor/Helpers/ServerInstaller.cs:478-508
Timestamp: 2025-10-13T13:41:00.086Z
Learning: In the MCPForUnityTools feature (MCPForUnity/Editor/Helpers/ServerInstaller.cs), the design intentionally forces users to have only one .py file per MCPForUnityTools folder to keep file tracking simple. Package-style tools (subdirectories with __init__.py) are not supported.

Learnt from: JohanHoltby
PR: CoplayDev/unity-mcp#309
File: MCPForUnity/Editor/Helpers/ServerInstaller.cs:478-508
Timestamp: 2025-10-13T13:41:00.086Z
Learning: In the MCPForUnityTools feature (MCPForUnity/Editor/Helpers/ServerInstaller.cs), the design intentionally forces users to have only one .py file per MCPForUnityTools folder to keep file tracking simple. Package-style tools (subdirectories with __init__.py) are not supported.